package com.java.zhuiyun.api.task.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.java.zhuiyun.annotation.OptLog;
import com.java.zhuiyun.api.SysUser.common.Result;
import com.java.zhuiyun.api.playerinformation.entity.PlayerInformation;
import com.java.zhuiyun.api.playerinformation.mapper.PlayerInformationMapper;
import com.java.zhuiyun.api.playerinformation.service.PlayerInformationService;
import com.java.zhuiyun.api.propmgt.entity.PropCenter;
import com.java.zhuiyun.api.propmgt.mapper.PropCenterMapper;
import com.java.zhuiyun.api.propmgt.mapper.PropMgtMapper;
import com.java.zhuiyun.api.task.entity.Task;
import com.java.zhuiyun.api.task.entity.TaskDto;
import com.java.zhuiyun.api.task.entity.Type;
import com.java.zhuiyun.api.task.mapper.TaskMapper;
import com.java.zhuiyun.api.task.service.ITaskService;
import com.java.zhuiyun.api.task.service.ITypeService;
import com.java.zhuiyun.common.response.CommonConstants;
import com.java.zhuiyun.common.response.CommonResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName TaskController
 * @Description TODO 任务管理 用于uniapp任务列表
 * @Author xy
 * @Date 2023/9/17 21:17
 **/
@RestController
@Api(tags = "任务管理")
@RequestMapping("/task")
@Slf4j
public class TaskController {

    @Resource
    private ITaskService taskService;

    @Resource
    private TaskMapper taskMapper;

    @Resource
    private ITypeService typeService;

    @Resource
    private PlayerInformationMapper playerInformationMapper;

    @Resource
    private PropCenterMapper propCenterMapper;

    @Resource
    private PlayerInformationService playerInformationService;

    /**
     * @Author xy
     * @Description todo 任务管理的添加修改方法（后台管理）
     * @param task 任务实体类
     * @Date 2023年9月17日21:18:59
     * @return Result 返回类型
     */
    @PostMapping("/save")
    @ApiOperation(value = "添加修改")
    @OptLog(modular = "任务管理", type = CommonConstants.ADD, describe = "添加修改")
    public Result save(@RequestBody Task task) {
        taskService.saveTask(task);
        return Result.success();
    }

    /**
     * @Author xy
     * @Description todo 任务管理的分页查询方法（后台管理）
     * @Date 2023年9月17日21:26:18
     * @Return Result 返回类型
     * @param tasksname 任务名称
     * @param pageNum 页码
     * @param pageSize 每页条数
     */
    @GetMapping("/page")
    @ApiOperation(value = "查询")
    @OptLog(modular = "任务管理", type = CommonConstants.SELECT, describe = "查询")
    public Result findPage(@RequestParam(defaultValue = "") String tasksname,
                           @RequestParam Integer pageNum,
                           @RequestParam Integer pageSize) {
        QueryWrapper<Task> queryWrapper = new QueryWrapper<>();
        if (!"".equals(tasksname)) {
            queryWrapper.like("tasksname", tasksname);
        }
        return Result.success(taskService.page(new Page<>(pageNum, pageSize), queryWrapper));
    }

    /**
    * @Author xy
    * @Description todo 任务管理的查询任务列表（uniapp）
    * @Date 2023/10/11 11:29
    * @Return Result 返回类型
    * @param openid 用户唯一标识
    * @param levelId 用户当前关卡
    */
    @GetMapping("/renwupage")
    @ApiOperation(value = "查询")
    @OptLog(modular = "任务管理", type = CommonConstants.SELECT, describe = "查询")
    public Result findrenwu(
            @RequestParam Integer pageNum,
            @RequestParam Integer pageSize,
            @RequestParam String openid,
            @RequestParam String levelId,
            @RequestParam Integer propCount) {
        TaskDto taskDto = new TaskDto();
        QueryWrapper<Task> queryWrapper = new QueryWrapper<>();
        // 筛选completion字段为0的数据 （未完成的任务）
        queryWrapper.eq("completion", 0);

        // 根据openid获取当前登录用户的信息
        PlayerInformation playerInformation = playerInformationMapper.selectOne(new QueryWrapper<PlayerInformation>().eq("openid", openid));
        // 获取当前用户的进度值
        List<PlayerInformation> playerInformations = playerInformationMapper.selectList(new QueryWrapper<PlayerInformation>().eq("openid", openid));

        // 获取当前登录用户的level_id
        int previousLevelId = playerInformation.getLevelId();

        // 获取用户之前的level_id
        int currentLevelId = Integer.parseInt(levelId);

        // 判断PlayerInformation当前登录的用户表里的level_id是否大于之前的level_id
        if (previousLevelId > currentLevelId){
            //跟据逗号分隔
            String[] split = playerInformation.getProgress().split(",");
            // 将数组里的第一个元素改为100
            split[0]="100";
            // 将数组转回字符串
            String splits = String.join(",", split);
            //重新赋值给PlayerInformation表里的progress字段
            playerInformation.setProgress(splits);
            playerInformationMapper.updateById(playerInformation);
        }

        // 获取用户秘境探险通关的次数
        Integer adventureIdNumber = playerInformation.getAdventureIdNumber();

        // 判断用户秘境探险通关的次数是否>=1 如果>=1则当前登录的用户的进度值progress就+100
        if (adventureIdNumber >= 1){
            //跟据逗号分隔
            String[] split = playerInformation.getProgress().split(",");
            // 将数组里的第一个元素改为100
            split[2]="100";
            // 将数组转回字符串
            String splits = String.join(",", split);
            //重新赋值给PlayerInformation表里的progress字段
            playerInformation.setProgress(splits);
            playerInformationMapper.updateById(playerInformation);
        }

        // 获取用户的道具数量
        List<PropCenter> propCenters = propCenterMapper.selectList(null);

        // 先判断用户是否有quantity道具 如果有就判断用户是否使用了2个道具 每使用一个道具则当前登录用户进度值progress就+50
        for (PropCenter propCenter : propCenters) {
            // 获取用户的道具数量
            int quantity = propCenter.getQuantity();

            // 判断用户是否拥有道具
            if (quantity > 0) {
                // 判断用户是否使用了2个道具
                //跟据逗号分隔
                String[] split = playerInformation.getProgress().split(",");
                // 将数组里的第一个元素改为100
                int a=0;
                for (int i = 0; i < propCount; i++) {
                    a += 50;
                }
                split[1]=Integer.toString(a);
                // 将数组转回字符串
                String splits = String.join(",", split);
                playerInformation.setProgress(splits);
                playerInformationMapper.updateById(playerInformation);
            }
        }
        taskDto.setTasks(taskService.page(new Page<>(pageNum, pageSize), queryWrapper).getRecords());
        taskDto.setPlayerInformation(playerInformations);
        return Result.success(taskDto);
    }

    /**
     * @Author xy
     * @Description todo 任务管理的领取奖励（新手任务） （uniapp）
     * @param
     * @Date 2023年9月17日21:18:59
     * @return CommonResult 返回类型
     */
    @ApiOperation(value = "任务管理的领取奖励（新手任务）")
    @OptLog(modular = "任务管理", type = CommonConstants.UPDATE, describe = "修改")
    @PostMapping("/receiveNovice")
    public CommonResult receiveNovice(@RequestBody PlayerInformation playerInformation) {
        // 获取当前用户的信息
        PlayerInformation currentUser = playerInformationMapper.selectOne(new QueryWrapper<PlayerInformation>().eq("openid", playerInformation.getOpenid()));
        if (currentUser != null) {
            // 增加积分
            currentUser.setCurrentPlayerScore(15);
            // 增加经验值
            currentUser.setCurrentPlayerExperience(15);
            playerInformationService.upPlayerLevel(currentUser);
        } else {
            return CommonResult.error("未找到当前用户");
        }
        return CommonResult.error("未找到当前用户");
    }

    /**
    * @Author xy
    * @Description todo 任务管理的领取奖励（秘境探险） （uniapp）
    * @Date 2023/10/16 9:10
    * @Return
    * @param
    */
    @ApiOperation(value = "任务管理的领取奖励（秘境探险）")
    @OptLog(modular = "任务管理", type = CommonConstants.UPDATE, describe = "修改")
    @PostMapping("/receiveNncharted")
    public CommonResult receiveNncharted(@RequestBody PlayerInformation playerInformation) {
        // 获取当前用户的信息
        PlayerInformation currentUser = playerInformationMapper.selectOne(new QueryWrapper<PlayerInformation>().eq("openid", playerInformation.getOpenid()));
        if (currentUser != null) {
            // 增加积分
            currentUser.setCurrentPlayerScore(100);
            // 增加经验值
            currentUser.setCurrentPlayerExperience(50);
            playerInformationService.upPlayerLevel(currentUser);
        } else {
            return CommonResult.error("未找到当前用户");
        }
        return CommonResult.error("未找到当前用户");
    }

    /**
    * @Author xy
    * @Description todo 任务管理的领取奖励（每日任务） （uniapp）
    * @Date 2023/10/16 10:01
    * @Return
    * @param
    */
    @ApiOperation(value = "任务管理的领取奖励（每日任务）")
    @OptLog(modular = "任务管理", type = CommonConstants.UPDATE, describe = "修改")
    @PostMapping("/receiveDaily")
    public CommonResult receiveDaily(@RequestBody PlayerInformation playerInformation) {
        // 获取当前用户的信息
        PlayerInformation currentUser = playerInformationMapper.selectOne(new QueryWrapper<PlayerInformation>().eq("openid", playerInformation.getOpenid()));
        if (currentUser != null) {
            // 增加积分
            currentUser.setCurrentPlayerScore(25);
            // 增加经验值
            currentUser.setCurrentPlayerExperience(25);
            playerInformationService.upPlayerLevel(currentUser);
        } else {
            return CommonResult.error("未找到当前用户");
        }
        return CommonResult.error("未找到当前用户");
    }

    /**
     * @Author xy
     * @Description todo 任务管理的逻辑删除接口 （后台管理）
     * @Date 2023年9月17日21:26:14
     * @Return Result 返回类型
     * @param id 任务id
     */
    @DeleteMapping("/{id}")
    @ApiOperation(value = "任务管理的逻辑删除接口")
    @OptLog(modular = "任务管理", type = CommonConstants.DELETE, describe = "删除")
    public Result delete(@PathVariable Integer id) {
        Task task = taskMapper.selectById(id);
        task.setDelFlag(true);
        taskMapper.deleteById(id);
        return Result.success();
    }

    /**
    * @Author xy
    * @Description todo 任务管理的类型下拉框 （后台管理）
    * @Date 2023/9/18 8:56
    * @Return Result 返回类型
    */
    @GetMapping("/taskstype")
    @ApiOperation(value = "任务管理的类型下拉框")
    @OptLog(modular = "任务管理", type = CommonConstants.SELECT, describe = "查询")
    public Result taskstype(){
        List<Type> list = typeService.list();
        return Result.success(list);
    }

}
